home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’97 / Klingon BG App / Source / speechUtil.c < prev    next >
Encoding:
Text File  |  1997-06-28  |  3.4 KB  |  189 lines  |  [TEXT/CWIE]
  1. // Source code for Klingon Clock.   Copyright (C) 1996-1997
  2. // Charles H. Hemstreet IV
  3. //
  4. // Started at MacHack 1996
  5. // Completed at MacHack 1997
  6. //
  7. // Best thanks to:
  8. // My wife Regie, son Chad and baby
  9. // Other thanks to Elden Wood and Bob Clark
  10. //
  11. // This code is distributed "as-is" and implies no warranty or guarantee.
  12.  
  13.  
  14. #ifndef __SPEECHUTIL__
  15. #include "speechUtil.h"
  16. #endif
  17.  
  18.  
  19. OSErr doSuccessSound(void)
  20. {
  21.     OSErr    myMainErr;
  22.  
  23.  
  24.     myMainErr = openSndChannel();
  25.     assert(myMainErr == noErr);
  26.  
  27.     myMainErr = LoadBufferSounds();
  28.     assert(myMainErr == noErr);
  29.  
  30.     // let the user know we were successful!!
  31.     myMainErr = doPlayASound(kKaplah, kPriority);
  32.     assert(myMainErr == noErr);
  33.     
  34.     waitCloseChannel();
  35.     
  36.     return myMainErr;
  37.     
  38. }
  39.  
  40.  
  41. OSErr speakSentence(short MySndID[], short MySndID1[], short MySndID2[])
  42. {
  43.     int     loop;
  44.     OSErr    myErr = noErr;
  45.     short    soundID;
  46.  
  47.  
  48.     myErr = openSndChannel();
  49.     assert(myErr == noErr);
  50.  
  51.     myErr = doPlayASound(kTime, kPriority);
  52.     assert(myErr == noErr);
  53.  
  54.     for (loop = 0; loop < kHoursMinutes; loop++) 
  55.     {
  56.         soundID = MySndID[loop];
  57.         myErr = doPlayASound(soundID, kPriority);
  58.         assert(myErr == noErr);
  59.         soundID = MySndID1[loop];
  60.         myErr = doPlayASound(soundID, kPriority);
  61.         assert(myErr == noErr);
  62.         soundID = MySndID2[loop];
  63.         myErr = doPlayASound(soundID, kPriority);
  64.         assert(myErr == noErr);
  65.     }
  66.  
  67.     waitCloseChannel();
  68.     
  69.     return myErr;
  70. }
  71.  
  72.  
  73. OSErr makeSentence(short cur_tick[], short MySndID[], short MySndID1[], short MySndID2[])
  74. {
  75.     int loop;
  76.     OSErr myErr = noErr;
  77.     
  78.       for (loop = 0; loop < kHoursMinutes; loop++) 
  79.       {
  80.         // if the unit is greater than ten, say ten
  81.         // klingon numbers are constructed with ten in the middle
  82.         // so that eleven is "one ten and one".  Twenty is "two tens"
  83.         // Default is null if not greater than 9.
  84.         if (cur_tick[loop] > 9) 
  85.         {
  86.             MySndID1[loop] = kTen;
  87.         }
  88.         else
  89.         {
  90.             MySndID1[loop] = NULL;
  91.         }
  92.  
  93.         // if the unit is greater than ten, then make sure you
  94.         // get the correct tens place number
  95.         // default is NULL if less than 10
  96.         if ((cur_tick[loop] > 9) && (cur_tick[loop] < 20)) 
  97.         {
  98.             MySndID[loop] = kOne;
  99.             cur_tick[loop] -= 10;
  100.             
  101.         } else if ((cur_tick[loop] > 19) && (cur_tick[loop] < 30)) 
  102.         {
  103.             MySndID[loop] = kTwo;
  104.             cur_tick[loop] -= 20;
  105.             
  106.         } else if ((cur_tick[loop] > 29) && (cur_tick[loop] < 40)) 
  107.         {
  108.             MySndID[loop] = kThree;
  109.             cur_tick[loop] -= 30;
  110.             
  111.         } else if ((cur_tick[loop] > 39) && (cur_tick[loop] < 50)) 
  112.         {
  113.             cur_tick[loop] -= 40;
  114.             MySndID[loop] = kFour;
  115.             
  116.         } else if ((cur_tick[loop] > 49) && (cur_tick[loop] <= 59)) 
  117.         {
  118.             cur_tick[loop] -= 50;
  119.             MySndID[loop] = kFive;
  120.         
  121.         } else 
  122.         {
  123.             MySndID[loop] = NULL;
  124.         }            
  125.         
  126.         // now take care of the ones place.  We will always get a ones place
  127.         //
  128.         switch (cur_tick[loop]) 
  129.         {
  130.             case 0:
  131.             {
  132.                 if (MySndID[loop] == NULL)
  133.                     MySndID2[loop] = kZero;
  134.                 else
  135.                     MySndID2[loop] = NULL;
  136.                 break;
  137.             }
  138.             case 1:
  139.             {
  140.                 MySndID2[loop] = kOne;
  141.                 break;
  142.             }
  143.             case 2:
  144.             {
  145.                 MySndID2[loop] = kTwo;
  146.                 break;
  147.             }
  148.             case 3:
  149.             {
  150.                 MySndID2[loop] = kThree;
  151.                 break;
  152.             }
  153.             case 4:
  154.             {
  155.                 MySndID2[loop] = kFour;
  156.                 break;
  157.             }
  158.             case 5:
  159.             {
  160.                 MySndID2[loop] = kFive;
  161.                 break;
  162.             }
  163.             case 6:
  164.             {
  165.                 MySndID2[loop] = kSix;
  166.                 break;
  167.             }
  168.             case 7:
  169.             {
  170.                 MySndID2[loop] = kSeven;
  171.                 break;
  172.             }
  173.             case 8:
  174.             {
  175.                 MySndID2[loop] = kEight;
  176.                 break;
  177.             }
  178.             case 9:
  179.             {
  180.                 MySndID2[loop] = kNine;
  181.                 break;
  182.             }
  183.             default:
  184.                 break;
  185.             }
  186.     }
  187.     return myErr;
  188. }
  189.